<?php

namespace Aws\S3;

use GuzzleHttp\Promise\PromiseInterface;
use GuzzleHttp\Promise\PromisorInterface;
use GuzzleHttp\Psr7;
use Psr\Http\Message\StreamInterface;

/**
 * Uploads an object to S3, using a PutObject command or a multipart upload as
 * appropriate.
 */
class ObjectUploader implements PromisorInterface {
	const DEFAULT_MULTIPART_THRESHOLD = 16777216;

	private $client;
	private $bucket;
	private $key;
	private $body;
	private $acl;
	private $options;
	private static $defaults = [
		'before_upload' => null,
		'concurrency' => 3,
		'mup_threshold' => self::DEFAULT_MULTIPART_THRESHOLD,
		'params' => [],
		'part_size' => null,
	];
	private $addContentMD5;

	/**
	 * @param S3ClientInterface $client The S3 Client used to execute
	 *                                          the upload command(s).
	 * @param string $bucket Bucket to upload the object, or
	 *                                          an S3 access point ARN.
	 * @param string $key Key of the object.
	 * @param mixed $body Object data to upload. Can be a
	 *                                          StreamInterface, PHP stream
	 *                                          resource, or a string of data to
	 *                                          upload.
	 * @param string $acl ACL to apply to the copy
	 *                                          (default: private).
	 * @param array $options Options used to configure the
	 *                                          copy process. Options passed in
	 *                                          through 'params' are added to
	 *                                          the sub command(s).
	 */
	public function __construct(
		S3ClientInterface $client,
		                  $bucket,
		                  $key,
		                  $body,
		                  $acl = 'private',
		array             $options = []
	) {
		$this->client = $client;
		$this->bucket = $bucket;
		$this->key = $key;
		$this->body = Psr7\Utils::streamFor($body);
		$this->acl = $acl;
		$this->options = $options + self::$defaults;
		// Handle "add_content_md5" option.
		$this->addContentMD5 = isset($options['add_content_md5'])
			&& $options['add_content_md5'] === true;
	}

	/**
	 * @return PromiseInterface
	 */
	public function promise() {
		/** @var int $mup_threshold */
		$mup_threshold = $this->options['mup_threshold'];
		if($this->requiresMultipart($this->body, $mup_threshold)) {
			// Perform a multipart upload.
			return (new MultipartUploader($this->client, $this->body, [
					'bucket' => $this->bucket,
					'key' => $this->key,
					'acl' => $this->acl
				] + $this->options))->promise();
		}

		// Perform a regular PutObject operation.
		$command = $this->client->getCommand('PutObject', [
				'Bucket' => $this->bucket,
				'Key' => $this->key,
				'Body' => $this->body,
				'ACL' => $this->acl,
				'AddContentMD5' => $this->addContentMD5
			] + $this->options['params']);
		if(is_callable($this->options['before_upload'])) {
			$this->options['before_upload']($command);
		}
		return $this->client->executeAsync($command);
	}

	public function upload() {
		return $this->promise()->wait();
	}

	/**
	 * Determines if the body should be uploaded using PutObject or the
	 * Multipart Upload System. It also modifies the passed-in $body as needed
	 * to support the upload.
	 *
	 * @param StreamInterface $body Stream representing the body.
	 * @param integer $threshold Minimum bytes before using Multipart.
	 *
	 * @return bool
	 */
	private function requiresMultipart(StreamInterface &$body, $threshold) {
		// If body size known, compare to threshold to determine if Multipart.
		if($body->getSize() !== null) {
			return $body->getSize() >= $threshold;
		}

		/**
		 * Handle the situation where the body size is unknown.
		 * Read up to 5MB into a buffer to determine how to upload the body.
		 * @var StreamInterface $buffer
		 */
		$buffer = Psr7\Utils::streamFor();
		Psr7\Utils::copyToStream($body, $buffer, MultipartUploader::PART_MIN_SIZE);

		// If body < 5MB, use PutObject with the buffer.
		if($buffer->getSize() < MultipartUploader::PART_MIN_SIZE) {
			$buffer->seek(0);
			$body = $buffer;
			return false;
		}

		// If body >= 5 MB, then use multipart. [YES]
		if($body->isSeekable() && $body->getMetadata('uri') !== 'php://input') {
			// If the body is seekable, just rewind the body.
			$body->seek(0);
		} else {
			// If the body is non-seekable, stitch the rewind the buffer and
			// the partially read body together into one stream. This avoids
			// unnecessary disc usage and does not require seeking on the
			// original stream.
			$buffer->seek(0);
			$body = new Psr7\AppendStream([$buffer, $body]);
		}

		return true;
	}
}
